package com.fengniao.goods.service.impl;

import com.alibaba.fastjson.JSON;
import com.fengniao.goods.dao.BrandMapper;
import com.fengniao.goods.dao.CategoryMapper;
import com.fengniao.goods.dao.SkuMapper;
import com.fengniao.goods.dao.SpuMapper;
import com.fengniao.goods.pojo.*;
import com.fengniao.goods.service.SpuService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import entity.DBOperUtil;
import entity.IdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

/****
 * @Author:shenkunlin
 * @Description:Spu业务层接口实现类
 * @Date 2019/6/14 0:16
 *****/
@Service
public class SpuServiceImpl implements SpuService {

    @Autowired
    private SpuMapper spuMapper;
    @Autowired
    private SkuMapper skuMapper;
    @Autowired
    private CategoryMapper categoryMapper;
    @Autowired
    private BrandMapper brandMapper;

    private IdWorker idWorker = new IdWorker(0,0);

    @Override
    public void putMany(Long[] spuIds) {
        // update tb_sku set IsMarketable = 1 where id in(ids) and is_delete = 0 and status = 1
        Example example = new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();

        // id in (ids)
        criteria.andIn("id", Arrays.asList(spuIds));
        // 未删除
        criteria.andEqualTo("isDelete", "0");
        // 已上架
        criteria.andEqualTo("status", "1");

        // 准备修改数据
        Spu spu = new Spu();
        spu.setIsMarketable("1"); // 上架
        int flag = spuMapper.updateByExampleSelective(spu, example);
        DBOperUtil.checkDBOper(flag, "批量上架失败");

    }

    @Override
    public void put(Long spuId) {
        // 查询商品
        Spu spu = spuMapper.selectByPrimaryKey(spuId);
        // 判断商品是否被删除
        if (spu.getIsDelete().equalsIgnoreCase("1")) {
            throw new RuntimeException("该商品已经被删除");
        }

        // 实现下架
        spu.setIsMarketable("1"); // 上架
        int flag = spuMapper.updateByPrimaryKeySelective(spu);
        DBOperUtil.checkDBOper(flag, "商品上架失败");
    }

    @Override
    public void pull(Long spuId) {
        // 查询商品
        Spu spu = spuMapper.selectByPrimaryKey(spuId);
        // 判断商品是否被删除
        if (spu.getIsDelete().equalsIgnoreCase("1")) {
            throw new RuntimeException("该商品已经被删除");
        }

        // 实现下架
        spu.setIsMarketable("0"); // 下架
        int flag = spuMapper.updateByPrimaryKeySelective(spu);
        DBOperUtil.checkDBOper(flag, "商品下架失败");
    }

    @Override
    public void audit(Long spuId) {
        // 查询商品
        Spu spu = spuMapper.selectByPrimaryKey(spuId);
        // 判断商品是否被删除
        if (spu.getIsDelete().equalsIgnoreCase("1")) {
            throw new RuntimeException("该商品已经被删除");
        }

        // 实现上架和审核
        spu.setStatus("1"); // 审核通过
        spu.setIsMarketable("1"); // 上架
        int flag = spuMapper.updateByPrimaryKeySelective(spu);
        DBOperUtil.checkDBOper(flag, "商品审核失败");
    }

    @Override
    public Goods findGoodsBySpuId(Long spuId) {
        // 1.查询spu
        Spu spu = spuMapper.selectByPrimaryKey(spuId);

        // 2.查询sku
        Sku sku = new Sku();
        sku.setSpuId(spuId);
        List<Sku> skuList = skuMapper.select(sku);

        // 如果商品的spu信息没有，那么就是商品信息
        DBOperUtil.ResultIsNull(spu, "没有找到该商品的信息");

        // 3.封装到goods并返回
        return new Goods(spu, skuList);
    }

    @SuppressWarnings("unchecked")
    @Override
    public void saveGoods(Goods goods) {
        // 添加与修改用同一个方法

        // 1.处理Spu
        Spu spu = goods.getSpu();
        // 1.1取出sku

        boolean isSave = spu.getId() == null;
        int spuSave = 0;
        int spuRevise = 0;
        int skuRevise = 0;
        if (isSave) {
            spu.setId(idWorker.nextId());
            spuSave = spuMapper.insertSelective(spu);
        } else {
            // 如果是更新操作,根据id修改spu
            spuRevise = spuMapper.updateByPrimaryKeySelective(spu);
            // 将旧的sku记录删除,再进行新增
            Sku oldSku = new Sku();
            oldSku.setSpuId(spu.getId());
            int delete = skuMapper.delete(oldSku);
            skuRevise += delete;
        }


        // 2.1查询所需分类数据
        Integer categoryId = spu.getCategory3Id();
        Category category = categoryMapper
                .selectByPrimaryKey(categoryId);
        // 2.2查询所需品牌数据
        Brand brand =
                brandMapper.selectByPrimaryKey(spu.getBrandId());

        // 2.3处理Sku
        Date date = new Date();
        List<Sku> skuList = goods.getSkuList();
        Integer skuFlag = 0;
        for (Sku sku : skuList) {

            sku.setId(idWorker.nextId());
            // 2.4处理名称 名称：spu的名称+sku的名称
            // sku的名称在spec中 spec中的数据是json格式
            // {"电视音响效果":"立体声","电视屏幕尺寸":"20英寸","尺码":"165"}
            if (StringUtils.isEmpty(spu.getName())) {
                // 防止空指针
                spu.setName("{}");
            }
            StringBuffer buffer = new StringBuffer(spu.getName());
            Map<String, String> map = JSON.parseObject(sku.getSpec(), Map.class);
            for (Map.Entry<String, String> entry : map.entrySet()) {
                buffer.append(" ").append(entry.getKey()).append(entry.getValue());
            }
            sku.setName(buffer.toString());
            sku.setCreateTime(date);
            sku.setUpdateTime(date);
            sku.setSpuId(spu.getId());
            // 分类ID->3级
            sku.setCategoryId(categoryId);
            // 分类名
            sku.setCategoryName(category.getName());
            // 品牌名
            sku.setBrandName(brand.getName());

            // 2.5添加到数据库中
            int flag = skuMapper.insertSelective(sku);
            // 2.6将影响的结果相加
            skuFlag += flag;
        }
        // 2.6如果spu和sku的信息都没有添加成功，则商品添加失败
        // 如果所有的修改返回为0，则商品修改失败
        if (isSave)
            DBOperUtil.checkDBOper(spuSave + skuFlag,"商品添加失败");
        else
            DBOperUtil.checkDBOper(spuRevise + skuRevise + skuFlag,"商品修改失败");

    }


    /**
     * Spu条件+分页查询
     * @param spu 查询条件
     * @param page 页码
     * @param size 页大小
     * @return 分页结果
     */
    @Override
    public PageInfo<Spu> findPage(Spu spu, int page, int size){
        //分页
        PageHelper.startPage(page,size);
        //搜索条件构建
        Example example = createExample(spu);
        //执行搜索
        return new PageInfo<Spu>(spuMapper.selectByExample(example));
    }

    /**
     * Spu分页查询
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Spu> findPage(int page, int size){
        //静态分页
        PageHelper.startPage(page,size);
        //分页查询
        return new PageInfo<Spu>(spuMapper.selectAll());
    }

    /**
     * Spu条件查询
     * @param spu
     * @return
     */
    @Override
    public List<Spu> findList(Spu spu){
        //构建查询条件
        Example example = createExample(spu);
        //根据构建的条件查询数据
        return spuMapper.selectByExample(example);
    }


    /**
     * Spu构建查询对象
     * @param spu
     * @return
     */
    public Example createExample(Spu spu){
        Example example=new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        if(spu!=null){
            // 主键
            if(!StringUtils.isEmpty(spu.getId())){
                    criteria.andEqualTo("id",spu.getId());
            }
            // 货号
            if(!StringUtils.isEmpty(spu.getSn())){
                    criteria.andEqualTo("sn",spu.getSn());
            }
            // SPU名
            if(!StringUtils.isEmpty(spu.getName())){
                    criteria.andLike("name","%"+spu.getName()+"%");
            }
            // 副标题
            if(!StringUtils.isEmpty(spu.getCaption())){
                    criteria.andEqualTo("caption",spu.getCaption());
            }
            // 品牌ID
            if(!StringUtils.isEmpty(spu.getBrandId())){
                    criteria.andEqualTo("brandId",spu.getBrandId());
            }
            // 一级分类
            if(!StringUtils.isEmpty(spu.getCategory1Id())){
                    criteria.andEqualTo("category1Id",spu.getCategory1Id());
            }
            // 二级分类
            if(!StringUtils.isEmpty(spu.getCategory2Id())){
                    criteria.andEqualTo("category2Id",spu.getCategory2Id());
            }
            // 三级分类
            if(!StringUtils.isEmpty(spu.getCategory3Id())){
                    criteria.andEqualTo("category3Id",spu.getCategory3Id());
            }
            // 模板ID
            if(!StringUtils.isEmpty(spu.getTemplateId())){
                    criteria.andEqualTo("templateId",spu.getTemplateId());
            }
            // 运费模板id
            if(!StringUtils.isEmpty(spu.getFreightId())){
                    criteria.andEqualTo("freightId",spu.getFreightId());
            }
            // 图片
            if(!StringUtils.isEmpty(spu.getImage())){
                    criteria.andEqualTo("image",spu.getImage());
            }
            // 图片列表
            if(!StringUtils.isEmpty(spu.getImages())){
                    criteria.andEqualTo("images",spu.getImages());
            }
            // 售后服务
            if(!StringUtils.isEmpty(spu.getSaleService())){
                    criteria.andEqualTo("saleService",spu.getSaleService());
            }
            // 介绍
            if(!StringUtils.isEmpty(spu.getIntroduction())){
                    criteria.andEqualTo("introduction",spu.getIntroduction());
            }
            // 规格列表
            if(!StringUtils.isEmpty(spu.getSpecItems())){
                    criteria.andEqualTo("specItems",spu.getSpecItems());
            }
            // 参数列表
            if(!StringUtils.isEmpty(spu.getParaItems())){
                    criteria.andEqualTo("paraItems",spu.getParaItems());
            }
            // 销量
            if(!StringUtils.isEmpty(spu.getSaleNum())){
                    criteria.andEqualTo("saleNum",spu.getSaleNum());
            }
            // 评论数
            if(!StringUtils.isEmpty(spu.getCommentNum())){
                    criteria.andEqualTo("commentNum",spu.getCommentNum());
            }
            // 是否上架,0已下架，1已上架
            if(!StringUtils.isEmpty(spu.getIsMarketable())){
                    criteria.andEqualTo("isMarketable",spu.getIsMarketable());
            }
            // 是否启用规格
            if(!StringUtils.isEmpty(spu.getIsEnableSpec())){
                    criteria.andEqualTo("isEnableSpec",spu.getIsEnableSpec());
            }
            // 是否删除,0:未删除，1：已删除
            if(!StringUtils.isEmpty(spu.getIsDelete())){
                    criteria.andEqualTo("isDelete",spu.getIsDelete());
            }
            // 审核状态，0：未审核，1：已审核，2：审核不通过
            if(!StringUtils.isEmpty(spu.getStatus())){
                    criteria.andEqualTo("status",spu.getStatus());
            }
        }
        return example;
    }

    /**
     * 删除
     * @param id
     */
    @Override
    public void delete(Long id){
        spuMapper.deleteByPrimaryKey(id);
    }

    /**
     * 修改Spu
     * @param spu
     */
    @Override
    public void update(Spu spu){
        spuMapper.updateByPrimaryKey(spu);
    }

    /**
     * 增加Spu
     * @param spu
     */
    @Override
    public void add(Spu spu){
        spuMapper.insert(spu);
    }

    /**
     * 根据ID查询Spu
     * @param id
     * @return
     */
    @Override
    public Spu findById(Long id){
        return  spuMapper.selectByPrimaryKey(id);
    }

    /**
     * 查询Spu全部数据
     * @return
     */
    @Override
    public List<Spu> findAll() {
        return spuMapper.selectAll();
    }
}
